/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Changes:
 * 2010-08-11 Steve McIntyre <steve.mcintyre@arm.com>
 *    Added small changes to the two functions to make them work on the
 *    specified number of 16- or 32-bit values rather than the original
 *    code which was specified as a count of bytes. More verbose comments
 *    to aid future maintenance.
 */
.text
.align 4
.syntax unified

.global arm_memset32
.hidden arm_memset32
.type   arm_memset32, %function

/*
* Optimized memset functions for ARM.
*
* void arm_memset32(uint32_t* dst, uint32_t value, int count);
*
*/
arm_memset32:
    .fnstart
    push        {lr}

    /* Multiply count by 4 - go from the number of 32-bit words to
     * the number of bytes desired. */
    mov         r2, r2, lsl #2

.Lwork_32:
    /* Set up registers ready for writing them out. */
    mov         ip, r1
    mov         lr, r1

    /* Try to align the destination to a cache line. Assume 32
     * byte (8 word) cache lines, it's the common case. */
    rsb         r3, r0, #0
    ands        r3, r3, #0x1C
    beq         .Laligned32
    cmp         r3, r2
    andhi       r3, r2, #0x1C
    sub         r2, r2, r3

    /* (Optionally) write any unaligned leading bytes.
     * (0-28 bytes, length in r3) */
    movs        r3, r3, lsl #28
    stmiacs     r0!, {r1, lr}
    stmiacs     r0!, {r1, lr}
    stmiami     r0!, {r1, lr}
    movs        r3, r3, lsl #2
    strcs       r1, [r0], #4

    /* Now quickly loop through the cache-aligned data. */
.Laligned32:
    mov         r3, r1
1:      subs        r2, r2, #32
    stmiahs     r0!, {r1,r3,ip,lr}
    stmiahs     r0!, {r1,r3,ip,lr}
    bhs         1b
    add         r2, r2, #32

    /* (Optionally) store any remaining trailing bytes.
     * (0-30 bytes, length in r2) */
    movs        r2, r2, lsl #28
    stmiacs     r0!, {r1,r3,ip,lr}
    stmiami     r0!, {r1,lr}
    movs        r2, r2, lsl #2
    strcs       r1, [r0], #4
    strhmi      lr, [r0], #2

.Lfinish:
    pop         {pc}
    .fnend